import cacheUtils from "@/utils/cache/cache.util";
import { getLogger } from "@/utils/logger";

// 创建常规日志记录器（不输出到控制台）
const logger = getLogger('cache-service', {
  console: false
});
// 创建控制台日志记录器
const consoleLogger = getLogger('cache-service');

const REDIS_PREFIX = process.env.REDIS_PREFIX || "ruoyi:";

const COMMON_CACHE_NAMES = [
	{ name: "login_tokens", remark: "用户信息" },
	{ name: "sys_config", remark: "配置信息" },
	{ name: "sys_dict", remark: "数据字典" },
	{ name: "captcha_codes", remark: "验证码" },
	{ name: "repeat_submit", remark: "防重提交" },
	{ name: "rate_limit", remark: "限流处理" },
	{ name: "pwd_err_cnt", remark: "密码错误次数" },
	{ name: "login_token_map", remark: "JWT与UUID映射关系" },
];

class CacheService {
  /**
   * 获取Redis基本信息、dbSize、命令统计
   */
  public async getInfo() {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info('获取Redis基本信息');
      
      const infoResult = await cacheUtils.info();
      const dbSizeResult = await cacheUtils.dbsize();
      const commandStatsResult = await cacheUtils.info("commandstats");
      
      // 解析 info
      const infoObj: Record<string, string> = {};
      if (infoResult.success && infoResult.data) {
        logger.debug('解析Redis info信息');
        infoResult.data.split('\n').forEach(line => {
          if (line && !line.startsWith('#')) {
            const [key, value] = line.split(':');
            if (key && value) infoObj[key] = value.trim();
          }
        });
      }
      
      // 解析 commandStats
      const pieList: { name: string; value: string }[] = [];
      if (commandStatsResult.success && commandStatsResult.data) {
        logger.debug('解析Redis命令统计信息');
        commandStatsResult.data.split('\n').forEach(line => {
          if (line.startsWith('cmdstat_')) {
            const name = line.split(':')[0].replace('cmdstat_', '');
            const value = line.match(/calls=(\d+)/)?.[1] || '0';
            pieList.push({ name, value });
          }
        });
      }
      
      const result = {
        info: infoObj,
        dbSize: dbSizeResult.success && typeof dbSizeResult.data === 'number' ? dbSizeResult.data : 0,
        commandStats: pieList
      };
      
      // 记录查询结果
      logger.info(`Redis基本信息查询完成: dbSize=${result.dbSize}, 命令统计数量=${pieList.length}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`获取Redis基本信息失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('获取Redis基本信息失败');
    }
  }

  /**
   * 获取常用缓存名称列表
   */
  public async getNames() {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info('获取常用缓存名称列表');
      
      const result = COMMON_CACHE_NAMES.map(item => ({
        cacheName: item.name.replace(new RegExp(`^${REDIS_PREFIX}`), ''),
        cacheKey: '',
        cacheValue: '',
        remark: item.remark
      }));
      
      // 记录查询结果
      logger.info(`常用缓存名称列表获取完成: 数量=${result.length}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`获取常用缓存名称列表失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('获取常用缓存名称列表失败');
    }
  }

  /**
   * 获取指定缓存名下所有key
   */
  public async getKeys(cacheName: string) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`获取缓存键列表: cacheName=${cacheName}`);
      
      const keysResult = await cacheUtils.keys(`${cacheName}:*`);
      let result: string[] = [];
      
      if (keysResult.success && keysResult.data) {
        result = keysResult.data.map(key => key.replace(`${REDIS_PREFIX}${cacheName}:`, '')).sort();
      }
      
      // 记录查询结果
      logger.info(`缓存键列表获取完成: cacheName=${cacheName}, 键数量=${result.length}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`获取缓存键列表失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('获取缓存键列表失败');
    }
  }

  /**
   * 获取指定key的值
   */
  public async getValue(cacheName: string, cacheKey: string) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`获取缓存值: cacheName=${cacheName}, cacheKey=${cacheKey}`);
      
      const redisKey = `${cacheName}:${cacheKey}`;
      const valueResult = await cacheUtils.get(redisKey);
      let value = null;
      
      if (valueResult.success && valueResult.data) {
        value = JSON.stringify(valueResult.data);
      }
      
      // 查找remark
      const item = COMMON_CACHE_NAMES.find(item => item.name.replace(new RegExp(`^${REDIS_PREFIX}`), '') === cacheName);
      const remark = item ? item.remark : '';
      
      const result = { cacheName, cacheKey, cacheValue: value, remark };
      
      // 记录查询结果
      logger.info(`缓存值获取完成: cacheName=${cacheName}, cacheKey=${cacheKey}, 是否有值=${value !== null}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`获取缓存值失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('获取缓存值失败');
    }
  }

  /**
   * 清理指定缓存名下所有key
   */
  public async clearCacheName(cacheName: string) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`清理缓存名称: cacheName=${cacheName}`);
      
      const keysResult = await cacheUtils.keys(`${cacheName}:*`);
      if (keysResult.success && keysResult.data && keysResult.data.length > 0) {
        // 去除 keyPrefix，确保 del 时不会重复加前缀
        const realKeys = keysResult.data.map(key => key.replace(REDIS_PREFIX, ""));
        
        logger.debug(`准备删除键: 缓存名称=${cacheName}, 键数量=${realKeys.length}`);
        
        if (realKeys.length > 0) {
          await cacheUtils.del(realKeys);
        }
      }
      
      // 记录操作结果
      logger.info(`缓存名称清理完成: cacheName=${cacheName}`);
    } catch (error) {
      consoleLogger.error(`清理缓存名称失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('清理缓存名称失败');
    }
  }

  /**
   * 清理指定key
   */
  public async clearCacheKey(cacheKey: string) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`清理缓存键: cacheKey=${cacheKey}`);
      
      const result = await cacheUtils.del(cacheKey);
      
      if (result.success) {
        logger.info(`缓存键清理成功: cacheKey=${cacheKey}`);
      } else {
        logger.warn(`缓存键清理失败: cacheKey=${cacheKey}, 错误=${result.error?.message || result.error}`);
      }
    } catch (error) {
      consoleLogger.error(`清理缓存键失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('清理缓存键失败');
    }
  }

  /**
   * 清理所有缓存
   */
  public async clearCacheAll() {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info('清理所有缓存');
      
      const keysResult = await cacheUtils.keys("*");
      if (keysResult.success && keysResult.data) {
        // 去除 keyPrefix，确保 del 时不会重复加前缀
        const realKeys = keysResult.data.map(key => key.replace(REDIS_PREFIX, ""));
        
        logger.debug(`准备删除所有键: 键数量=${realKeys.length}`);
        
        if (realKeys.length > 0) {
          await cacheUtils.del(realKeys);
        }
      }
      
      // 记录操作结果
      logger.info('所有缓存清理完成');
    } catch (error) {
      consoleLogger.error(`清理所有缓存失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('清理所有缓存失败');
    }
  }
}

export default new CacheService(); 